package cn.imnu.legalaid.controller;

import cn.imnu.legalaid.entity.User;
import cn.imnu.legalaid.service.UserService;
import cn.imnu.legalaid.util.JwtUtil;
import cn.imnu.legalaid.util.Result;
import com.auth0.jwt.exceptions.JWTDecodeException;
import com.auth0.jwt.exceptions.JWTVerificationException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.security.crypto.bcrypt.BCryptPasswordEncoder;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.*;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;


import java.util.HashMap;
import java.util.Map;
import java.util.regex.Pattern;


@RestController
@RequestMapping("/auth")
public class AuthController {

    private static final String BEARER_PREFIX = "Bearer ";
    private static final Logger logger = LoggerFactory.getLogger(AuthController.class);


    @Autowired
    private UserService userService;

    @Autowired
    private JwtUtil jwtUtil;

    private final BCryptPasswordEncoder passwordEncoder = new BCryptPasswordEncoder();
    private final Pattern emailPattern = Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");


    @PostMapping("/login")
    public Result<Map<String, Object>> login(@RequestParam String username,
                                             @RequestParam String password) {
        // 输入验证
        if (!StringUtils.hasText(username) || !StringUtils.hasText(password)) {
            return Result.error("用户名和密码不能为空");
        }

        User user = userService.getUserByUsername(username);
        if (user == null) {
            return Result.error("用户不存在");
        }

        // 使用BCrypt验证密码
        if (!passwordEncoder.matches(password, user.getPasswordHash())) {
            return Result.error("密码错误");
        }

        // 修复状态比较问题
        if (user.getStatus() != User.UserStatus.ACTIVE) {
            return Result.error("账户已被禁用");
        }

        // 更新最后登录时间
        userService.updateLastLogin(user.getId());

        // 生成token
        String token = jwtUtil.generateToken(user);

        // 返回用户信息（不包含敏感数据）和token
        Map<String, Object> result = new HashMap<>();
        Map<String, Object> userInfo = new HashMap<>();
        userInfo.put("id", user.getId());
        userInfo.put("username", user.getUsername());
        userInfo.put("email", user.getEmail());
        userInfo.put("role", user.getRole());
        userInfo.put("realName", user.getRealName());
        userInfo.put("avatar", user.getAvatarUrl());

        result.put("user", userInfo);
        result.put("token", token);
        return Result.success(result, "登录成功");

    }

    @PostMapping("/register")
    public Result<Boolean> register(@RequestBody User user) {
        // 输入验证
        if (!StringUtils.hasText(user.getUsername())) {
            return Result.error("用户名不能为空");
        }
        
        // 添加用户名格式验证
        if (user.getUsername().length() < 3 || user.getUsername().length() > 20) {
            return Result.error("用户名长度必须在3-20位之间");
        }
        
        Pattern usernamePattern = Pattern.compile("^[a-zA-Z0-9_]{3,20}$");
        if (!usernamePattern.matcher(user.getUsername()).matches()) {
            return Result.error("用户名只能包含字母、数字和下划线");
        }
        
        if (!StringUtils.hasText(user.getPasswordHash())) {
            return Result.error("密码不能为空");
        }
        if (!StringUtils.hasText(user.getEmail())) {
            return Result.error("邮箱不能为空");
        }

        // 邮箱格式验证
        if (!emailPattern.matcher(user.getEmail()).matches()) {
            return Result.error("邮箱格式不正确");
        }

        // 密码复杂度验证（至少8位，包含字母和数字）
        if (user.getPasswordHash().length() < 8) {
            return Result.error("密码长度不能少于8位");
        }

        // 添加密码复杂度验证
        Pattern passwordPattern = Pattern.compile("^(?=.*[a-zA-Z])(?=.*\\d).{8,}$");
        if (!passwordPattern.matcher(user.getPasswordHash()).matches()) {
            return Result.error("密码必须包含字母和数字");
        }


        // 检查用户名是否已存在
        if (userService.getUserByUsername(user.getUsername()) != null) {
            return Result.error("用户名已存在");
        }

        // 检查邮箱是否已存在
        if (userService.getUserByEmail(user.getEmail()) != null) {
            return Result.error("邮箱已存在");
        }

        // 使用BCrypt加密密码
        String encryptedPassword = passwordEncoder.encode(user.getPasswordHash());
        user.setPasswordHash(encryptedPassword);

        // 设置默认值（使用枚举类型）
        user.setRole(User.UserRole.CLIENT);
        user.setStatus(User.UserStatus.ACTIVE);

        boolean success = userService.createUser(user);
        if (success) {
            return Result.success(true, "注册成功");
        } else {
            return Result.error("注册失败");
        }
    }

    @PostMapping("/logout")
    public Result<Boolean> logout(@RequestHeader(value = "Authorization", required = false) String token) {
        // JWT是无状态的，服务端不需要存储token状态
        // 实际的登出逻辑由前端处理（删除本地存储的token）
        
        // 可选：验证token格式是否正确（不验证有效性）
        if (token != null && token.startsWith("Bearer ")) {
            // 日志记录用户登出（可选）
            String actualToken = token.substring(7);
            try {
                // 这里可以记录登出日志，但不验证token有效性
                // 因为即使token过期，用户也应该能够登出
                System.out.println("用户登出，token: " + actualToken.substring(0, Math.min(10, actualToken.length())) + "...");
            } catch (Exception e) {
                // 忽略token解析错误，允许登出
                System.out.println("用户登出请求");
            }
        }
        
        return Result.success(true, "登出成功");
    }

    // 添加 token 验证接口
    @PostMapping("/validate-token")
    public Result<Map<String, Object>> validateToken(@RequestHeader(value = "Authorization") String authHeader) {
        try {
            // 检查 Authorization 头是否存在
            if (!StringUtils.hasText(authHeader) || !authHeader.startsWith(BEARER_PREFIX)) {
                return Result.error(401, "无效的认证信息");
            }

            // 提取 token
            String token = authHeader.substring(BEARER_PREFIX.length());
            
            // 验证 token 有效性和是否过期
            if (!jwtUtil.verify(token) || jwtUtil.isExpired(token)) {
                return Result.error(401, "Token 已失效或过期");
            }

            // 从 token 中提取用户名
            String username = jwtUtil.getUsername(token);
            if (!StringUtils.hasText(username)) {
                return Result.error(401, "无效的 Token");
            }

            // 获取用户信息
            User user = userService.getUserByUsername(username);
            if (user == null) {
                return Result.error(401, "用户不存在");
            }

            // 检查用户状态
            if (user.getStatus() != User.UserStatus.ACTIVE) {
                return Result.error(403, "账户已被禁用");
            }

            // 返回用户信息（不包含敏感数据）
            Map<String, Object> userInfo = new HashMap<>();
            userInfo.put("id", user.getId());
            userInfo.put("username", user.getUsername());
            userInfo.put("email", user.getEmail());
            userInfo.put("role", user.getRole());
            userInfo.put("realName", user.getRealName());
            userInfo.put("avatar", user.getAvatarUrl());
            userInfo.put("status", user.getStatus());

            Map<String, Object> result = new HashMap<>();
            result.put("user", userInfo);
            result.put("valid", true);

            logger.info("用户 {} token 验证成功", userInfo.get("username"));


            return Result.success(result, "Token 验证成功");

        } catch (JWTVerificationException e) {
            logger.warn("JWT token 验证失败: {}", e.getMessage());
            return Result.error(401, "Token 验证失败");
        } catch (Exception e) {
            logger.error("Token 验证异常", e);
            return Result.error(500, "服务器内部错误");
        }

    }
}
